In the context of three-dimensional (3D) computer graphics (especially with video games, simulations, or the like), real-time graphics processing is important. It is common for computer-graphics (CG) systems to generate 25-60 frames per second (fps). CG systems must generate a two-dimensional (2 D) view of a computer-generated 3D world.
Consequently, many known techniques exist to enhance the speed and efficiency of a CG system. Many of these approaches are directed towards effective and efficient management of the memory of a graphics processing unit (GPU) of a CG system. A key element of efficiency is to reduce the amount of memory required, which reduces the cost of the memory. Another key element of efficiency is reducing the number of memory accesses required, which reduces both the cost of the memory and the amount of power required to access memory.
A common approach is to compress the data stored in memory to reduce the bandwidth (BW) requirements. Many common memory compression methods are lossless, meaning that decompression exactly restores the compressed data. These methods use additional bits per block of memory, referred to as meta-data, to specify the degree of compression. The meta-data is stored in a memory array typically referred to as a control plane. Typically, the meta-data is defined to support a single block size and a single compression method.
Another approach to enhance the speed and efficiency of a CG system involves reducing the total data stored in memory. Some CG applications use large arrays of data, out of which only a small region is required for rendering any particular frame. The memory array may be many times larger than the amount used on a given frame. This occurs in cases such as texture map that store highly detailed image data for which only a small amount is used in a given frame. It also occurs for cases such as arrays or more complex data structures representing objects to render, where only a small amount of the object data is needed in a single frame.
A known solution on CPUs is to use virtual address translation with page faulting. This solution depends on being able to suspend processing while waiting for data to be loaded into memory in response to the page fault. This cannot be used for real time graphics applications because the time required to respond to a page fault is a large fraction of the time required to render a single frame. Therefore, for real time graphics the required data must be predicted and loaded in advance, instead of loading it only when accessed.
A known solution to this problem for real time graphics is a technique referred to as Tiled Resources. The key idea is to divide the memory resource into an array of tiles of some moderate size, e.g. 64 KB. The tiles represent a linear sequence of memory for a data structure, a 2 D region for a 2 D array, or a 3D region for a volumetric array. The application then selects the tiles required to render a given frame and maps them to memory using a new type of virtual address translation table that is controlled by the application. As a result, a small “tile pool” stores the tiles required out of the larger memory array, thus dramatically reducing the amount of memory required to access the memory resource.
Tiles that are not mapped to memory are typically referred to as “null” tiles. The application-controlled address translation table specifies that such tiles are null instead of providing a translation address. Unlike traditional virtual addressing, accessing a null tile does not cause a fault or delay. Applications may detect these null accesses when reading from memory and then compute some alternate result. If that is not done, reading from a null tile returns a constant value, typically zeros, and writes to a null tile are ignored. This is necessary since there is no actual memory backing up an access to a null tile. Null access semantics need to be enforced both with and without the use of meta-data bits for compression.
The Detailed Description references the accompanying figures. In the figures, the left-most digit(s) of a reference number identifies the figure in which the reference number first appears. The same numbers are used throughout the drawings to references like features and components.